home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / ProgEd / sources / ped_searchfold / C_FuncFolder.c next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  5.6 KB  |  264 lines
  1.  
  2. /***** Include vari *****/
  3.  
  4. #include "/triton/ped/Ped.h"
  5. #include <strings.h>
  6. #include <math.h>
  7.  
  8.  
  9. /***** Prototipi delle due funzioni che si trovano in fondo al programma.
  10.     Cio' e' necessario per far si che la funzione principale sia la
  11.     prima nel codice! *****/
  12.  
  13. struct Line *MySearchLine( struct Line * , int );
  14. void MyStrRev( char * );
  15.  
  16.  
  17.  
  18. /*****
  19.  *
  20.  * FUNZIONE:    ULONG main(struct PEDWindow *p,LONG ccol,LONG cline,ULONG *start,ULONG *end,char *funcname)
  21.  *
  22.  * SCOPO:    Cerca un blocco racchiuso dalle parentesi '{' e '}' che si
  23.  *        trovi a livello 0 (non racchiuso da un altro blocco dello
  24.  *        stesso tipo).
  25.  *
  26.  * NOTA:    Utilizza SEMPRE la funzione geta4() o la direttiva __saveds!
  27.  *
  28.  * RESTITUISCE: TRUE=blocco trovato,FALSE=non trovato.
  29.  *
  30.  ****/
  31.  
  32. ULONG ASM SAVEDS main(RG(a0) struct PEDWindow *p,RG(d0) LONG ccol,RG(d1) LONG cline,RG(a1) ULONG *start,RG(a2) ULONG *end,RG(a3) char *funcname)
  33. {
  34.     struct Line    *line,
  35.             *curstartline;
  36.     int         i,
  37.              n,
  38.              num,
  39.              level,
  40.              lev,
  41.              nline,
  42.              startline,
  43.              startcol,
  44.              try;
  45.     char         c,
  46.             *pun;
  47.  
  48.  
  49.  
  50.     /***** Scorri dal cursore in su per capire a che livello (di
  51.         parentesi graffe) siamo *****/
  52.  
  53.     curstartline=line=MySearchLine(p->Text->FirstLine,cline);
  54.     n=ccol;
  55.     level=0;
  56.     while(line)
  57.     {
  58.         /***** Se trovo un FOLD certamente sono a livello 0 *****/
  59.         if (line->Folder)    break;
  60.  
  61.         /***** Cerca una graffa sulla riga *****/
  62.         for(i=n;i>=0;i--)
  63.         {
  64.             c=line->Buffer[i];
  65.  
  66.             /***** Se c'e' una { aumenta il livello *****/
  67.             if (c=='{') level++;
  68.  
  69.             /***** Se c'e' una } diminuisci il livello *****/
  70.             else if (c=='}') level--;
  71.         }
  72.  
  73.         /***** Passiamo alla linea precedente *****/
  74.         line=line->PrevLine;
  75.         if (line)    n=strlen(line->Buffer)-1;
  76.     }
  77.  
  78.     /***** Se sei a livello 0, certamente non sei in una funzione! *****/
  79.     if (!level)    return(FALSE);
  80.  
  81.     /***** Altrimenti scorri dal cursore in su fino a scendere al
  82.         livello 0 *****/
  83.     line=curstartline;
  84.     nline=cline;
  85.     n=ccol;
  86.     lev=level;
  87.     while(line)
  88.     {
  89.         /***** Cerca una graffa sulla riga *****/
  90.         for(i=n;i>=0;i--)
  91.         {
  92.             c=line->Buffer[i];
  93.             /***** Se c'e' una { diminuisci il livello. Se sei
  94.                 arrivato a livello 0 esci dal ciclo. *****/
  95.             if (c=='{')
  96.             {
  97.                 if (!(--lev))    break;
  98.             }
  99.  
  100.             /***** Se c'e' una } aumenta il livello *****/
  101.             else if (c=='}') lev++;
  102.         }
  103.  
  104.         /***** Se siamo arrivati al livello 0 esci da quest'altro
  105.             ciclo *****/
  106.         if (i>=0)    break;
  107.  
  108.         /***** Passiamo alla linea precedente *****/
  109.         line=line->PrevLine;
  110.         nline--;
  111.         if (line)    n=strlen(line->Buffer)-1;
  112.     }
  113.  
  114.     /***** Se line==NULL allora c'e' stato un'errore!!!!!!!!!!!!!! *****/
  115.     if (!line)    return(FALSE);
  116.  
  117.     /***** Abbiamo trovato l'inizio del blocco. Memorizza la posizione in
  118.         (startline,startcol) *****/
  119.     startline=nline;
  120.     startcol=i;
  121.  
  122.     /***** Partiamo di nuovo dal punto iniziale e scorriamo verso il basso
  123.         fino a scendere al livello 0 (dove termina il blocco). *****/
  124.     line=curstartline;
  125.     nline=cline;
  126.     n=ccol+1;
  127.     lev=level;
  128.     while(line)
  129.     {
  130.         /***** Cerca una graffa sulla riga *****/
  131.         for(i=n;i<strlen(line->Buffer);i++)
  132.         {
  133.             c=line->Buffer[i];
  134.             /***** Se c'e' una { aumenta di livello *****/
  135.             if (c=='{')    lev++;
  136.             /***** Se c'e' una } diminuisci di livello. Se siamo
  137.                 a livello 0 esci da questo ciclo. *****/
  138.             else if (c=='}') if (!(--lev))    break;
  139.         }
  140.  
  141.         /***** Se siamo arrivati al livello 0 esci da quest'altro
  142.             ciclo *****/
  143.         if (i<strlen(line->Buffer))    break;
  144.  
  145.         /***** Passiamo alla linea successiva *****/
  146.         line=line->NextLine;
  147.         nline++;
  148.         n=0;
  149.     }
  150.  
  151.     /***** Se line==NULL allora c'e' stato un'errore!!!!!!!!!!!!!! *****/
  152.     if (!line)    return(FALSE);
  153.  
  154.     /***** Abbiamo trovato anche la fine del blocco. Memorizza le righe
  155.         iniziali e finali del blocco nelle LONG a cui puntato i
  156.         parametri "start" ed "end". *****/
  157.     *start=startline;
  158.     *end=nline;
  159.  
  160.     /***** Cerchiamo il nome della funzione,ora. Trova la prima '('
  161.         prima dell'inizio del blocco.*****/
  162.     line=MySearchLine(p->Text->FirstLine,startline);
  163.     nline=startline;
  164.     n=startcol;
  165.     try=3;    /* <- Cerchiamo per 3 linee prima dell'inizio del blocco */
  166.     while(line)
  167.     {
  168.         for(i=n;i>=0;i--)    if (line->Buffer[i]=='(')    break;
  169.  
  170.         if (i>=0)    break;
  171.  
  172.         line=line->PrevLine;
  173.         nline--;
  174.  
  175.         if (!(--try))    break;
  176.  
  177.         if (line)    n=strlen(line->Buffer)-1;
  178.     }
  179.  
  180.     /***** Se line==NULL o hai superato le 3 linee permesse allora
  181.         restituisci una stringa nulla come nome della funzione
  182.         (Basta ritornare perche' la stringa nulla e' il nome
  183.         di default fornito da ProgED). *****/
  184.     if ((!line)||(!try))    return(TRUE);
  185.  
  186.     /***** Torna indietro dalla '(' trovata ricostruendo il nome
  187.         della funzione. *****/
  188.     num=0;
  189.     pun=funcname;
  190.     for(i--;i>=0;i--)
  191.     {
  192.         c=line->Buffer[i];
  193.         if (
  194.             ((c>='a')&&(c<='z'))
  195.             ||
  196.             ((c>='A')&&(c<='Z'))
  197.             ||
  198.             ((c>='0')&&(c<='9'))
  199.             ||
  200.             (c=='_')
  201.         )    *pun++=c;
  202.         else break;
  203.     }
  204.     *pun='\0';
  205.  
  206.     /***** Il nome, pero', e' scritto al contrario! Invertilo! ******/
  207.     MyStrRev(funcname);
  208.  
  209.     /***** Aggiusta l'inizio del blocco fino ad includere la riga su
  210.         cui si trovava il nome della funzione e ritorna TRUE. ******/
  211.     *start=max(0,nline);
  212.     return(TRUE);
  213. }
  214.  
  215.  
  216.  
  217. /*****
  218.  *
  219.  * FUNZIONE:    struct Line *MySearchLine(struct Line *line,int y)
  220.  *
  221.  * SCOPO:    Cerca l'indirizzo della linea "y-esima" (0=prima) a partire
  222.  *        dalla prima linea del file data da line.
  223.  *        NB: NON tiene conto dei FOLDS.
  224.  *
  225.  * RESTITUISCE: Un puntatore alla linea cercata.
  226.  *
  227.  ****/
  228.  
  229. struct Line *MySearchLine(struct Line *line,int y)
  230. {
  231.     while(((y--)>0)&&(line))    line=line->NextLine;
  232.     return(line);
  233. }
  234.  
  235.  
  236.  
  237. /*****
  238.  *
  239.  * FUNZIONE:    void MyStrRev(char *p)
  240.  *
  241.  * SCOPO:    Inverte la stringa puntata da p.
  242.  *
  243.  * RESTITUISCE: -
  244.  *
  245.  ****/
  246.  
  247. void MyStrRev(char *p)
  248. {
  249.     char    c;
  250.     int    i,
  251.         n;
  252.  
  253.     n=strlen(p);
  254.     for(i=0;i<n/2;i++)
  255.     {
  256.         c=p[i];
  257.         p[i]=p[n-1-i];
  258.         p[n-1-i]=c;
  259.     }
  260. }
  261.  
  262.  
  263.  
  264.